import browser, { type WebRequest } from 'webextension-polyfill'

class LanhuBackground {
  svgRequests: Map<string, any> = new Map()
  constructor() {
    this.init()
  }

  init() {
    this.setupEventListeners()
    this.setupSvgInterceptor() // 添加SVG拦截器
    this.initializeExtension()
  }

  get svgList() {
    return [...this.svgRequests.values()]
  }

  async getSvgSize() {
    try {
      // 获取当前活动的标签页
      const tabs = await browser.tabs.query({ active: true, currentWindow: true })
      if (tabs.length === 0) return

      const tab = tabs[0]
      if (!tab?.id) return

      // 向 content script 发送消息请求页面信息
      const response = await browser.tabs.sendMessage(tab.id, {
        action: 'getSvgSize',
      })
      // @ts-expect-error --any
      return response.data
    } catch (error) {
      console.error('获取页面元素失败:', error)
    }
  }

  setupEventListeners() {
    // 必需：处理popup消息

    browser.runtime.onMessage.addListener((request, sender, sendResponse) => {
      this.handleMessage(request as any, sender, sendResponse)
      return true // Keep message channel open for async responses
    })

    // 有用：插件安装/更新时的处理
    browser.runtime.onInstalled.addListener((details) => {
      this.handleInstallation(details)
    })

    // 可选：浏览器启动时的处理（用于调试）
    browser.runtime.onStartup.addListener(() => {
      this.handleStartup()
    })

    // 将来可能有用：标签页更新监听（比如检测蓝湖页面）
    browser.tabs.onUpdated.addListener((tabId, changeInfo, tab) => {
      // 当页面加载完成且是蓝湖网站时，可以做一些初始化
      if (changeInfo.status === 'complete' && tab.url) {
        const isLanhuSite = tab.url.includes('lanhuapp.com') || tab.url.includes('lanhu.com')
        if (isLanhuSite) {
          console.log('检测到蓝湖页面:', tab.url)
          // 将来可以在这里注入content script或显示页面图标
        }
      }
    })

    console.log('事件监听器设置完成')
  }

  onBeforeRequestListener(details: WebRequest.OnBeforeRequestDetailsType) {
    try {
      // 检查tabId是否有效（-1表示不是来自tab的请求）
      if (details.tabId === -1) {
        return // 跳过非tab请求
      }
      const lanhuSvgPattern = /^https:\/\/.*lanhu.*oss.*SVG.*/
      if (!lanhuSvgPattern.test(details.url)) {
        return // 不匹配蓝湖SVG模式，跳过
      }

      // 检查是否已经处理过这个URL
      const urlKey = `processed_${details.url}`

      if (this.svgRequests.has(urlKey)) {
        return // 已处理过，跳过
      }

      this.captureSvgAsync(details.url)
    } catch (error) {
      console.error('SVG拦截器处理请求时出错:', error)
    }
  }

  setupSvgInterceptor() {
    this.setupDeclarativeRules()

    // 监听响应头来捕获SVG内容
    browser.webRequest.onBeforeRequest.addListener(this.onBeforeRequestListener.bind(this), {
      urls: ['https://*.lanhuapp.com/*'],
      types: ['xmlhttprequest'],
    })

    console.log('✅ SVG拦截器已设置')
  }

  removeSvgInterceptor() {
    this.removeDeclarativeRules()
    browser.webRequest.onBeforeRequest.removeListener(this.onBeforeRequestListener.bind(this))
    console.log('✅ SVG拦截器已移除')
  }

  async captureSvgAsync(url: string) {
    try {
      const { width, height } = await this.getSvgSize()
      const svgData = {
        url: url,
        width,
        height,
      }

      this.saveSvgData(svgData)
      console.log('✅ SVG已保存:', url)
    } catch (error) {
      console.error('获取SVG失败:', error)
    }
  }

  // 设置声明式网络请求规则
  async setupDeclarativeRules() {
    try {
      // 清除现有规则
      await browser.declarativeNetRequest.updateDynamicRules({
        removeRuleIds: [1], // 移除可能存在的规则
      })

      // 添加新规则来阻止SVG下载
      await browser.declarativeNetRequest.updateDynamicRules({
        addRules: [
          {
            id: 1,
            priority: 1,
            action: {
              type: 'block',
            },
            condition: {
              regexFilter: '^https://.*lanhu.*oss.*SVG.*',
              resourceTypes: ['xmlhttprequest'],
            },
          },
        ],
      })

      console.log('✅ 声明式网络请求规则已设置')
    } catch (error) {
      console.error('设置声明式网络请求规则失败:', error)
    }
  }

  // 移除声明式网络请求规则
  async removeDeclarativeRules() {
    try {
      await browser.declarativeNetRequest.updateDynamicRules({
        removeRuleIds: [1], // 移除SVG拦截规则
      })
      console.log('✅ 拦截规则已移除')
    } catch (error) {
      console.error('移除拦截规则失败:', error)
    }
  }

  // 保存SVG数据
  async saveSvgData(svgData: { url: string; tabId?: number }) {
    const key = `processed_${svgData.url}`
    // 将SVG内容保存到内存中
    this.svgRequests.set(key, {
      ...svgData,
    })
    try {
      this.addSvgListListener()
    } catch (error) {
      console.error('发送消息失败:', error)
    }
  }

  // 新增：消息处理方法
  async handleMessage(
    request: { action: string; data?: any },
    sender: browser.Runtime.MessageSender,
    sendResponse: (response: { success: boolean; error?: string }) => void,
  ) {
    console.log('收到消息:', request.action)

    try {
      switch (request.action) {
        case 'clearSvgData':
          await this.clearSvgData()
          sendResponse({ success: true })
          break
        case 'toggleInterception':
          await this.toggleInterception(request.data)
          sendResponse({ success: true })
          break

        default:
          sendResponse({ success: false, error: 'Unknown action' })
      }
    } catch (error) {
      console.error('处理消息失败:', error)
      sendResponse({ success: false, error: (error as Error).message })
    }
  }

  // @ts-expect-error - browser.tabs.query callback signature mismatch
  async toggleInterception(data) {
    if (data) {
      this.setupSvgInterceptor()
    } else {
      this.removeSvgInterceptor()
    }
  }

  async addSvgListListener() {
    try {
      const tabs = await browser.tabs.query({ url: ['*://*.lanhuapp.com/*', '*://*.lanhu.com/*'] })
      tabs.forEach((tab) => {
        if (tab.id) {
          browser.tabs
            .sendMessage(tab.id, {
              action: 'svgCaptured',
              data: this.svgList,
            })
            .catch((error) => {
              // 静默处理连接错误
              console.log(`📝 向标签页 ${tab.id} 发送消息失败:`, error.message)
            })
        }
      })
    } catch (error) {
      console.error('查询标签页失败:', error)
    }
  }

  // 清除SVG数据
  async clearSvgData() {
    try {
      this.svgRequests.clear()
      this.addSvgListListener()
    } catch (error) {
      console.error('清除SVG数据失败:', error)
    }
  }

  // 初始化扩展
  async initializeExtension() {
    try {
      console.log('蓝湖SVG拦截器后台脚本已初始化')
    } catch (error) {
      console.error('初始化扩展失败:', error)
    }
  }

  // 处理安装
  async handleInstallation(details: browser.Runtime.OnInstalledDetailsType) {
    if (details.reason === 'install') {
      console.log('蓝湖SVG拦截器已安装')
    } else if (details.reason === 'update') {
      console.log('蓝湖SVG拦截器已更新')
    }
  }

  // 处理启动
  handleStartup() {
    console.log('蓝湖SVG拦截器已启动')
  }

  // 处理标签页更新

  async handleTabUpdate(tabId, changeInfo, tab) {
    // 可以在这里添加标签页更新逻辑
  }

  // 处理右键菜单点击
  async handleContextMenuClick(info, tab) {
    // 可以在这里添加右键菜单逻辑
  }
}

// 初始化后台脚本
new LanhuBackground()
